home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / gui / MR_Classes.lha / MR_Classes / Dev / Source / palette / dispatch.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-04  |  8.2 KB  |  363 lines
  1. #define DEBUG
  2. #include <debug.h>
  3.  
  4. #include "ui.h"
  5. #include "edata.h"
  6.  
  7. #include <clib/alib_protos.h>
  8. #include <clib/extras/string_protos.h>
  9.  
  10. #include <classes/requesters/palette.h>
  11.  
  12. #include <proto/intuition.h>
  13. #include <proto/exec.h>
  14. #include <proto/graphics.h>
  15. #include <proto/utility.h>
  16.  
  17. #include <exec/memory.h>
  18.  
  19. #include <math.h>
  20.  
  21. #include <tagitemmacros.h>
  22.  
  23. // OBSOLETE
  24.  
  25. ULONG soSetAttrs(Class *C, Object *Obj, struct opSet *Set);
  26. ULONG soGetAttrs(Class *C, Object *Obj, struct opGetAttrs *Get);
  27. ULONG soGetAttr(Class *C, Object *Obj, struct opGet *Get);
  28. STRPTR copystring(STRPTR Source, STRPTR *dest);
  29.  
  30. ULONG __saveds __asm EditorDispatcher(register __a0 Class *C, register __a2 Object *Obj, register __a1 Msg M, register __a6 struct Library *Lib)
  31. {
  32.   struct SData *sdata;
  33.   ULONG retval=0;
  34.  
  35. //  sdata=INST_DATA(C, Obj);
  36.  
  37.   switch(M->MethodID)
  38.   {
  39.     case OM_NEW:
  40.       //DKP("OM_NEW\n");
  41.       if(Obj=(Object *)DoSuperMethodA(C,Obj,(Msg)M))
  42.       {
  43.         sdata=INST_DATA(C, Obj);
  44.         
  45.         if(i_NewWindowObject(C,Obj,(APTR)M))
  46.         {
  47.           soSetAttrs(C,Obj,(struct opSet *)M);
  48.           retval=(ULONG)Obj;
  49.         }
  50.         else
  51.         {
  52.           retval=0;
  53.           DoSuperMethod(C,Obj,OM_DISPOSE);
  54.         }
  55.       }
  56.       break;
  57.  
  58.     case OM_DISPOSE:
  59.       //DKP("OM_DISPOSE\n");
  60. //      Delay(60);
  61.       i_DisposeWindowObject(C,Obj);
  62.       //DKP("Window disposed\n");
  63. //      Delay(60);
  64.       retval=DoSuperMethodA(C,Obj,(Msg)M);
  65.       break;
  66.  
  67.     case OM_SET:
  68.       //DKP("OM_SET\n");
  69.       retval=soSetAttrs(C,Obj,(struct opSet *)M);
  70.       break;
  71.  
  72.     case OM_GET:
  73.       //DKP("OM_GET\n");
  74.       retval=soGetAttr(C,Obj,(struct opGet *)M);
  75.       break;
  76.  
  77.  
  78.  
  79. //    case OM_GETATTRS:
  80. //      retval=soGetAttrs(C,Obj,(struct opGetAttrs *)M);
  81.       break;
  82.  
  83.     case RM_DOREQUEST:
  84.       //DKP("MPEM_EDIT\n");
  85.       retval=i_OpenEditor(C,Obj,(APTR)M);      
  86. //      Delay(60);
  87.       //DKP("  end MPEM_EDIT\n");
  88. //      Delay(60);
  89.       break;
  90.       
  91. /*
  92.     case OM_DUPEOBJECT:
  93.       {
  94.         retval=soDupeObject(C, Obj);        
  95.       }
  96.       break;*/
  97. /*    case MPM_MATCHSCREEN:
  98. */    
  99.  
  100.  
  101.     default:
  102.       retval=DoSuperMethodA(C,Obj,(Msg)M);
  103.       break;
  104.   }
  105.   return(retval);
  106. }
  107.  
  108.  
  109. ULONG soSetAttrs(Class *C, Object *Obj, struct opSet *Set)
  110. {
  111.   struct EData *edata;
  112.   struct TagItem *tag,*tstate;
  113.   ULONG retval=0,data;
  114.  
  115.   edata=INST_DATA(C, Obj);
  116.   
  117.   ProcessTagList(Set->ops_AttrList,tag,tstate)
  118.   {
  119.     data=tag->ti_Data;
  120.     switch(tag->ti_Tag)
  121.     {
  122.      case PR_Screen:
  123.         DKP("  PR_Screen %8lx\n",data);
  124.         edata->pr_Screen=(struct Screen *)data;
  125.         edata->pr_Window=((struct Window *)0);
  126.         edata->pr_PubScreenName=(STRPTR)0;
  127.         
  128.         SetAttrs(edata->Win_Object, WA_CustomScreen,    data, 
  129.                                     WINDOW_Position,    WPOS_CENTERSCREEN,
  130.                                     TAG_DONE);
  131.         break;
  132.  
  133.       case PR_Window:
  134.         DKP("  PR_Window %8lx\n",data);
  135.         edata->pr_Window=(struct Window *)data;
  136.         edata->pr_Screen=(struct Screen *)0;
  137.         edata->pr_PubScreenName=(STRPTR)0;
  138.  
  139.         SetAttrs(edata->Win_Object, WINDOW_RefWindow,   data, 
  140.                                     WINDOW_Position,    WPOS_CENTERWINDOW,
  141.                                     TAG_DONE);
  142.         break;
  143.         
  144.       case PR_PubScreenName:
  145.         DKP("  PR_PubScreenName %s\n",data);
  146.         edata->pr_PubScreenName=(STRPTR)data;
  147.  
  148.         edata->pr_Window=(struct Window *)0;
  149.         edata->pr_Screen=(struct Screen *)0;
  150.  
  151.         SetAttrs(edata->Win_Object, WA_PubScreenName,   data,
  152.                                     WINDOW_Position,    WPOS_CENTERSCREEN,
  153.                                     TAG_DONE);
  154.         break;
  155.    
  156.       case PR_Colors:
  157.         //DKP("  PR_Colors %ld\n",data);
  158.         
  159.         data=max(1,data);
  160.         data=min(data,256);
  161.         edata->pr_Colors=data;
  162.  
  163.         //SetGadgetAttrs(edata->G_Palette, edata->Window, 0, TCPALETTE_NumColors, data, TAG_DONE);
  164.         break;
  165.    
  166.       case PR_InitialPalette:
  167.         //DKP("  PR_InitialPalette %8lx\n",data);
  168.         {
  169.           struct prRGB *rgb;
  170.           ULONG l;
  171.           
  172.           rgb=(APTR)data;
  173.           
  174.           for(l=0;l<edata->pr_Colors;l++)
  175.             edata->pr_InitialPalette[l]=rgb[l];
  176.         }
  177.         break;
  178.         
  179. /*
  180.       case PR_ObtainPens:
  181.         //DKP("  PR_ObtainPens %8lx\n",data);
  182.         edata->pr_Flags|=PRFLAG_OBTAINPENS;
  183.         edata->pr_PenMode=PR_ObtainPens;
  184.         break;
  185.  
  186.       case PR_ObtainBestPens:
  187.         //DKP("  PR_ObtainBestPens %8lx\n",data);
  188.         edata->pr_PenMode=PR_ObtainBestPens;
  189.         break;
  190.         
  191.       case PR_ColorTable:
  192.         //DKP("  PR_ColorTable %8lx\n",data);
  193.         edata->pr_UserColorTable=(APTR)data;
  194.         edata->pr_PenMode=PR_ColorTable;
  195.         break;
  196. */
  197.         
  198.       case PR_TextAttr:
  199.         //DKP("  PR_TextAttr %8lx\n",data);
  200.         edata->pr_TextAttr=(APTR)data;
  201.         break;
  202.         
  203.       case PR_TitleText:
  204.         //DKP("  PR_Title %s\n",data);
  205.         edata->pr_TitleText=(APTR)data;
  206.         break;
  207.         
  208.       case PR_RedBits:
  209.         edata->pr_Flags&=(~PRFLAG_USER_REDBITS);
  210.         if(data)
  211.         {
  212.           edata->pr_RedBits=data;
  213.           edata->pr_Flags|=PRFLAG_USER_REDBITS;
  214.         }
  215.         break;
  216.         
  217.       case PR_GreenBits:
  218.         edata->pr_Flags&=(~PRFLAG_USER_GREENBITS);
  219.         if(data)
  220.         {
  221.           edata->pr_GreenBits=data;
  222.           edata->pr_Flags|=PRFLAG_USER_GREENBITS;
  223.         }
  224.         break;
  225.         
  226.       case PR_BlueBits:
  227.         edata->pr_Flags&=(~PRFLAG_USER_BLUEBITS);
  228.         if(data)
  229.         {
  230.           edata->pr_BlueBits=data;
  231.           edata->pr_Flags|=PRFLAG_USER_BLUEBITS;
  232.         }
  233.         break;
  234.         
  235.       case PR_ModeIDRGBBits:
  236.         {
  237.           struct DisplayInfo di;
  238.           
  239.           //DKP("  PR_ModeIDRGBBits %8x\n",data);
  240.           
  241.           if(GetDisplayInfoData(0,(UBYTE *)&di,sizeof(di),DTAG_DISP,data))
  242.           {
  243.             edata->pr_RedBits   =max(di.RedBits,1);
  244.             edata->pr_GreenBits =max(di.GreenBits,1);
  245.             edata->pr_BlueBits  =max(di.BlueBits,1);
  246.             
  247.             edata->pr_Flags|=PRFLAG_USER_REDBITS|PRFLAG_USER_GREENBITS|PRFLAG_USER_BLUEBITS;
  248.           }
  249.         }
  250.         break;
  251.         
  252.       case PR_InitialLeftEdge:
  253.         edata->pr_Flags&=(~PRFLAG_USER_LEFTEDGE);
  254.         if(data>=0)
  255.         {
  256.           edata->pr_Flags|=(PRFLAG_USER_LEFTEDGE);
  257.           edata->pr_InitialLeftEdge=data;
  258.         }
  259.         break;
  260.         
  261.       case PR_InitialTopEdge:
  262.         edata->pr_Flags&=(~PRFLAG_USER_TOPEDGE);
  263.         if(data>=0)
  264.         {
  265.           edata->pr_Flags|=(PRFLAG_USER_TOPEDGE);
  266.           edata->pr_InitialTopEdge=data;
  267.         }
  268.         break;
  269.         
  270.       case PR_InitialWidth:
  271.         edata->pr_Flags&=(~PRFLAG_USER_WIDTH);
  272.         if(data>=0)
  273.         {
  274.           edata->pr_Flags|=(PRFLAG_USER_WIDTH);
  275.           edata->pr_InitialWidth=data;
  276.         }
  277.         break;
  278.       case PR_InitialHeight:
  279.         edata->pr_Flags&=(~PRFLAG_USER_HEIGHT);
  280.         if(data>=0)
  281.         {
  282.           edata->pr_Flags|=(PRFLAG_USER_HEIGHT);
  283.           edata->pr_InitialHeight=data;
  284.         }
  285.         break;
  286.         
  287.       case PR_PositiveText:
  288.         edata->pr_PositiveText=data;
  289.         break;
  290.  
  291.       case PR_NegativeText:
  292.         edata->pr_NegativeText=data;
  293.         break;
  294.         
  295.         
  296.     } // endswitch()
  297.   }// in ProcessTagList()
  298.  
  299.   return(retval);
  300. }
  301.  
  302. ULONG soGetAttr(Class *C, Object *Obj, struct opGet *Get)
  303. {
  304.   struct EData *edata;
  305. /*
  306.   union 
  307.   {
  308.     struct TTextAttr *ta;
  309.     struct RGB *rgb;
  310.     APTR   aptr;
  311.     STRPTR strptr;
  312.     ULONG  ulong;
  313.   } *data;
  314.   */
  315.  
  316.   ULONG retval=0;
  317.  
  318.   edata=INST_DATA(C, Obj);
  319.   
  320.   switch(Get->opg_AttrID)
  321.   {
  322.     case PR_Palette:
  323. //      GetAttr(TCPALETTE_RGBPalette, edata->G_Palette, Get->opg_Storage);
  324.       memcpy(Get->opg_Storage,edata->pr_InitialPalette, edata->pr_Colors * sizeof(struct prRGB) );//   (44.3.2) (09/03/00)
  325.       retval=1;
  326.       break;
  327.   }
  328.   return(retval);
  329. }
  330.  
  331.  
  332.  
  333. STRPTR copystring(STRPTR Source, STRPTR *dest)
  334. {
  335.   STRPTR ns;
  336.  
  337.   if(Source)
  338.   {
  339.     if(ns=CopyString(Source,MEMF_PUBLIC))
  340.     {
  341.       FreeVec(*dest);
  342.       *dest=ns;
  343.       return(ns);
  344.     }
  345.     else
  346.     {
  347.       FreeVec(*dest);
  348.       *dest=0;
  349.     }
  350.   }
  351.   return(*dest);
  352. }
  353.  
  354.  
  355. struct PData
  356. {
  357.   struct SData  *SData;
  358.   struct Screen *Screen;
  359.   WORD   Width,Height,Depth;
  360. };
  361.  
  362.  
  363.